home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_300 / 311_01 / db_var.c < prev    next >
C/C++ Source or Header  |  1990-04-21  |  11KB  |  456 lines
  1. /****************************************************************************/
  2. /*                                                                          */
  3. /*                                                                          */
  4. /*      db_var.c  v1.3  (c) 1990  Ken Harris                                */
  5. /*                                                                          */
  6. /*                                                                          */
  7. /****************************************************************************/
  8. /*                                                                          */
  9. /*      This software is made available on an AS-IS basis. Unrestricted     */
  10. /*      use is granted provided that the copyright notice remains intact.   */
  11. /*      The author makes no warranties expressed or implied.                */
  12. /*                                                                          */
  13. /****************************************************************************/
  14.  
  15. #include "dblib.h"
  16.  
  17. #ifdef ANSI
  18. void db_var_bld_csum(BUFFER);
  19. void db_var_chk_csum(BUFFER);
  20. #else
  21. void db_var_bld_csum();
  22. void db_var_chk_csum();
  23. #endif
  24.  
  25. /*
  26.  *      db_add_var  -  Add a record to a variable file
  27.  */
  28.  
  29. void db_add_var(df, user_data, data_size)
  30.  DATA_FILE df;
  31.  char *user_data;
  32.  int data_size;
  33. {
  34.         FILE_HDR  fh;
  35.         BUFFER   buf;
  36.         VAR_REC  vbuf;
  37.  
  38.         db_error = 0;
  39.  
  40.         fh  = (FILE_HDR) df->df_fhdr->buf_data;
  41.         buf = df->df_buf;
  42.  
  43.         buf->buf_cur_blk  = fh->fh_vfile_size;
  44.         buf->buf_rec_inx  = 0;
  45.     buf->buf_cur_size = sizeof(struct db_var_rec) + data_size;
  46.  
  47.     if (data_size < 1 || buf->buf_cur_size > buf->buf_size)
  48.     {    db_error = DB_VAR_SIZE_ERROR;
  49.         return;
  50.     }
  51.  
  52.         db_add_blk = buf->buf_cur_blk;
  53.         db_add_rec = buf->buf_rec_inx;
  54.  
  55.         vbuf = (VAR_REC) buf->buf_data;
  56.     vbuf->var_stat  = DB_INUSE;
  57.     vbuf->var_dsize = data_size;
  58.  
  59.         memcpy(vbuf->var_data, user_data, data_size);
  60.     db_var_bld_csum(buf);
  61.  
  62.         fh->fh_rec_cnt++;
  63.     fh->fh_vfile_size += buf->buf_cur_size;
  64.  
  65.         db_put_blk(df,df->df_fhdr);
  66.         db_put_blk(df,buf);
  67. }
  68.  
  69. /*
  70.  *      db_read_first_var  -  Read First Record in a Variable File
  71.  */
  72.  
  73. void db_read_first_var(df, user_data, data_size)
  74.  DATA_FILE df;
  75.  char *user_data;
  76.  int  *data_size;
  77. {
  78.         FILE_HDR fh;
  79.         BUFFER  buf;
  80.         VAR_REC vrec;
  81.         ulong   psn;
  82.  
  83.         db_error = 0;
  84.  
  85.         fh   = (FILE_HDR) df->df_fhdr->buf_data;
  86.         buf  = df->df_buf;
  87.     vrec = (VAR_REC) buf->buf_data;
  88.  
  89.         for (psn=DB_FILE_HDR_SIZE; psn < fh->fh_vfile_size;)
  90.         {       db_get_blk(df, psn, buf);
  91.                 if (db_error) return;
  92.  
  93.         db_var_chk_csum(buf);
  94.         if (db_error) return;
  95.  
  96.         buf->buf_cur_size = sizeof(struct db_var_rec) 
  97.                   + vrec->var_dsize;
  98.  
  99.         if (vrec->var_stat == DB_INUSE)
  100.         {    *data_size = vrec->var_dsize;
  101.             memcpy(user_data, vrec->var_data, *data_size);
  102.             return;
  103.         }
  104.  
  105.         psn += buf->buf_cur_size;
  106.         }
  107.         db_error= DB_END_OF_FILE;
  108. }
  109.  
  110. /*
  111.  *      db_read_next_var  -  Read Next Record in a Variable File
  112.  */
  113.  
  114. void db_read_next_var(df, user_data, data_size)
  115.  DATA_FILE df;
  116.  char *user_data;
  117.  int  *data_size;
  118. {
  119.         FILE_HDR fh;
  120.         BUFFER  buf;
  121.         VAR_REC vrec;
  122.         ulong   psn;
  123.  
  124.         db_error = 0;
  125.  
  126.         fh   = (FILE_HDR) df->df_fhdr->buf_data;
  127.         buf  = df->df_buf;
  128.         vrec = (VAR_REC) buf->buf_data;
  129.  
  130.     psn = df->df_prev_blk + df->df_prev_vsize;
  131.  
  132.         while (psn < fh->fh_vfile_size)
  133.         {       db_get_blk(df, psn, buf);
  134.                 if (db_error) return;
  135.  
  136.         db_var_chk_csum(buf);
  137.         if (db_error) return;
  138.  
  139.         buf->buf_cur_size = sizeof(struct db_var_rec) 
  140.                   + vrec->var_dsize;
  141.  
  142.         if (vrec->var_stat == DB_INUSE)
  143.         {    *data_size = vrec->var_dsize;
  144.             memcpy(user_data, vrec->var_data, *data_size);
  145.             return;
  146.         }
  147.  
  148.         psn += buf->buf_cur_size;
  149.         }
  150.         db_error= DB_END_OF_FILE;
  151. }
  152.  
  153. /*
  154.  *      db_read_last_var  -  Read Last Record in a Variable File
  155.  */
  156.  
  157. void db_read_last_var(df, user_data, data_size)
  158.  DATA_FILE df;
  159.  char *user_data;
  160.  int  *data_size;
  161. {
  162.         FILE_HDR fh;
  163.         BUFFER  buf;
  164.         VAR_REC vrec;
  165.         ulong   psn;
  166.     char   *c, *d;
  167.     short   vsize;
  168.  
  169.  
  170.         db_error = 0;
  171.  
  172.         fh   = (FILE_HDR) df->df_fhdr->buf_data;
  173.         buf  = df->df_buf;
  174.  
  175.         for (psn=fh->fh_vfile_size; psn >= DB_FILE_HDR_SIZE;)
  176.         {       psn -= buf->buf_size;
  177.         db_get_blk(df, psn, buf);
  178.                 if (db_error) return;
  179.         psn = buf->buf_cur_blk;
  180.  
  181.         c = buf->buf_data + buf->buf_cur_size - 2;
  182.         d = (char *)&vsize;
  183.  
  184.         *d++ = *c++;
  185.         *d   = *c;
  186.  
  187.         buf->buf_rec_inx  = buf->buf_size 
  188.                   - sizeof(struct db_var_rec) - vsize;
  189.         buf->buf_cur_size = sizeof(struct db_var_rec) + vsize;
  190.  
  191.         db_var_chk_csum(buf);
  192.         if (db_error) return;
  193.  
  194.         vrec = (VAR_REC)(buf->buf_data + buf->buf_rec_inx);
  195.  
  196.         if (vrec->var_stat == DB_INUSE)
  197.         {    *data_size = vrec->var_dsize;
  198.             memcpy(user_data, vrec->var_data, *data_size);
  199.             return;
  200.         }
  201.         }
  202.         db_error= DB_END_OF_FILE;
  203. }
  204.  
  205. /*
  206.  *      db_read_prev_var  -  Read Previous Record in a Variable File
  207.  */
  208.  
  209. void db_read_prev_var(df, user_data, data_size)
  210.  DATA_FILE df;
  211.  char *user_data;
  212.  int  *data_size;
  213. {
  214.         FILE_HDR fh;
  215.         BUFFER  buf;
  216.         VAR_REC vrec;
  217.         ulong   psn;
  218.     char   *c, *d;
  219.     short   vsize;
  220.  
  221.  
  222.         db_error = 0;
  223.  
  224.         fh   = (FILE_HDR) df->df_fhdr->buf_data;
  225.         buf  = df->df_buf;
  226.  
  227.         for (psn=df->df_prev_blk+df->df_prev_rec; psn >= DB_FILE_HDR_SIZE;)
  228.         {       psn -= buf->buf_size;
  229.         db_get_blk(df, psn, buf);
  230.                 if (db_error) return;
  231.         psn = buf->buf_cur_blk;
  232.  
  233.         c = buf->buf_data + buf->buf_cur_size - 2;
  234.         d = (char *)&vsize;
  235.  
  236.         *d++ = *c++;
  237.         *d   = *c;
  238.  
  239.         buf->buf_rec_inx  = buf->buf_cur_size 
  240.                   - sizeof(struct db_var_rec) - vsize;
  241.         buf->buf_cur_size = sizeof(struct db_var_rec) + vsize;
  242.  
  243.         db_var_chk_csum(buf);
  244.         if (db_error) return;
  245.  
  246.         vrec = (VAR_REC)(buf->buf_data + buf->buf_rec_inx);
  247.  
  248.         if (vrec->var_stat == DB_INUSE)
  249.         {    *data_size = vrec->var_dsize;
  250.             memcpy(user_data, vrec->var_data, *data_size);
  251.             return;
  252.         }
  253.         }
  254.         db_error= DB_END_OF_FILE;
  255. }
  256.  
  257. /*
  258.  *      db_update_var  -  Update Record in a Variable File
  259.  */
  260.  
  261. void db_update_var(df, user_data)
  262.  DATA_FILE df;
  263.  char *user_data;
  264. {
  265.         FILE_HDR  fh;
  266.         BUFFER   buf;
  267.         VAR_REC  vrec;
  268.  
  269.         db_error = 0;
  270.  
  271.         fh  = (FILE_HDR) df->df_fhdr->buf_data;
  272.         buf = df->df_buf;
  273.  
  274.         if (buf->buf_cur_blk == 0)
  275.         {       db_error = DB_NO_CURRENT_REC;
  276.                 return;
  277.         }
  278.  
  279.     vrec = (VAR_REC)(buf->buf_data + buf->buf_rec_inx);
  280.  
  281.         if (vrec->var_stat != DB_INUSE)
  282.         {       db_error = DB_DELETED_REC;
  283.                 return;
  284.         }
  285.  
  286.         memcpy(vrec->var_data, user_data, vrec->var_dsize);
  287.  
  288.     db_var_bld_csum(buf);
  289.  
  290.         db_put_blk(df, buf);
  291. }                           
  292.  
  293. /*
  294.  *      db_delete_var  -  Delete Record in a Variable File
  295.  */
  296.  
  297. void db_delete_var(df)
  298.  DATA_FILE df;
  299. {
  300.         FILE_HDR  fh;
  301.         BUFFER   buf;
  302.         VAR_REC  vrec;
  303.     char    *c;
  304.     int      i;
  305.  
  306.         db_error = 0;
  307.  
  308.         fh  = (FILE_HDR) df->df_fhdr->buf_data;
  309.         buf = df->df_buf;
  310.  
  311.         if (buf->buf_cur_blk == 0)
  312.         {       db_error = DB_NO_CURRENT_REC;
  313.                 return;
  314.         }
  315.  
  316.     vrec = (VAR_REC)(buf->buf_data + buf->buf_rec_inx);
  317.  
  318.         if (vrec->var_stat != DB_INUSE)
  319.         {       db_error = DB_DELETED_REC;
  320.                 return;
  321.         }
  322.  
  323.     vrec->var_stat = DB_FREE;
  324.     for (i=0, c=vrec->var_data; i < vrec->var_dsize; i++) *c++ = 0;
  325.  
  326.     fh->fh_rec_cnt--;
  327.  
  328.     db_var_bld_csum(buf);
  329.  
  330.         db_put_blk(df, buf);
  331.     db_put_blk(df,buf);
  332. }                           
  333.  
  334. /*
  335.  *      db_reorg_var  -  Reorganize a Variable File 
  336.  */
  337.  
  338. void db_reorg_var(new_df)
  339.  DATA_FILE new_df;
  340. {
  341.     DATA_FILE old_df;
  342.     FILE_HDR  old_fh, new_fh;
  343.         c